import org.xilin.User
import org.xilin.Role
import org.xilin.Family
import org.springframework.security.providers.UsernamePasswordAuthenticationToken as AuthToken
import org.springframework.security.context.SecurityContextHolder as SCH
import org.springframework.mail.javamail.MimeMailMessage
import javax.mail.internet.MimeMessage
import org.springframework.mail.javamail.MimeMessageHelper

/**
 * Registration controller.
 */
class RegisterController {

    def authenticateService
    def daoAuthenticationProvider
    //def emailerService
    def mailSender

    static Map allowedMethods = [save: 'POST', update: 'POST']

    /**
     * User Registration Top page.
     */
    def index = {

        // skip if already logged in
        if (authenticateService.isLoggedIn()) {
            redirect action: show
            return
        }

        if (session.id) {
            def person = new User()
            person.properties = params
            return [person: person]
        }

        redirect uri: '/'
    }

    /**
     * User Information page for current user.
     */
    def show = {

        // get user id from session's domain class.
        def user = authenticateService.userDomain()
        if (user) {
            render view: 'show', model: [person: User.get(user.id)]
        }
        else {
            redirect action: index
        }
    }

    /**
     * Edit page for current user.
     */
    def edit = {

        def person
        def user = authenticateService.userDomain()
        if (user) {
            person = User.get(user.id)
        }

        if (!person) {
            flash.message = "[Illegal Access] User not found with id ${params.id}"
            redirect action: index
            return
        }

        [person: person]
    }

    /**
     * update action for current user's edit page
     */
    def update = {

        def person
        def user = authenticateService.userDomain()
        if (user) {
            person = User.get(user.id)
        }
        else {
            redirect action: index
            return
        }

        if (!person) {
            flash.message = "[Illegal Access] User not found with id ${params.id}"
            redirect action: index, id: params.id
            return
        }

        // if user want to change password. leave passwd field blank, passwd will not change.
        if (params.passwd && params.passwd.length() > 0
            && params.repasswd && params.repasswd.length() > 0) {
            if (params.passwd == params.repasswd) {
                person.passwd = authenticateService.encodePassword(params.passwd)
            }
            else {
                person.passwd = ''
                flash.message = 'The passwords you entered do not match.'
                render view: 'edit', model: [person: person]
                return
            }
        }

	//	person.userRealName = params.userRealName
        person.email = params.email
        if (params.emailShow) {
            person.emailShow = true
        }
        else {
            person.emailShow = false
        }

        if (person.save()) {
            redirect action: show, id: person.id
        }
        else {
            render view: 'edit', model: [person: person]
        }
    }

    /**
     * Person save action.
     */
    def save = {
        // skip if already logged in
        if (authenticateService.isLoggedIn()) {
            redirect action: show
            return
        }

               
        def family = new Family(userId: params.username)
        // family.userId = person.username
        family.properties = params
        def person = new User()
        person.properties = params
        //       person.userRealName = params.fatherFirstName + " " + params.fatherLastName
		

        def config = authenticateService.securityConfig
        def defaultRole = config.security.defaultRole

        def role = Role.findByAuthority(defaultRole)
        if (!role) {
            person.passwd = ''
            flash.message = 'Default Role not found.'
            render view: 'index', model: [person: person]
            return
        }

        if (params.captcha.toUpperCase() != session.captcha) {
            person.passwd = ''
            flash.message = 'Access code did not match.'
            render view: 'index', model: [person: person]
            return
        }

        if (params.passwd != params.repasswd) {
            person.passwd = ''
            flash.message = 'The passwords you entered do not match.'
            render view: 'index', model: [person: person]
            return
        }

        person.pass = params.passwd
        def pass = authenticateService.encodePassword(params.passwd)
        person.passwd = pass
        person.enabled = false
        person.emailShow = true
        person.description = ''
        def code = (person.username.size() *person.email.size()* 7).toString()
        if(person.validate() && family.validate()) {
            role.addToPeople(person)
            if (config.security.useMail) {
                String emailContent = """<html><body>You have signed up for an account at:<br>

 ${request.scheme}://${request.serverName}:${request.serverPort}${request.contextPath} <br><br>

 Here are the details of your account: <br>
 -------------------------------------<br>
 LoginName: ${person.username} <br>
 Email: ${person.email} <br>
----------------------------------------- <br><br>

To activate your account, please click the following link: <br>
<a href="${request.scheme}://${request.serverName}:${request.serverPort}${request.contextPath}/login/activate?username=${person.username}&code=${code}">Activate my account</a>
</body></html>
"""
           /*   def email = [
                to: [person.email], // 'to' expects a List, NOT a single email address
                subject: "[${request.contextPath}] Account Signed Up",
                text: emailContent // 'text' is the email body
                ] 
                emailerService.sendEmails([email]) */
                MimeMessage message = mailSender.createMimeMessage();
                MimeMessageHelper helper = new MimeMessageHelper(message);
                helper.setTo([person.email]);
                helper.setText(emailContent, true);
                helper.setSubject("[${request.contextPath}] Account Signed Up")
                mailSender.send(message);
                
            }
            family.save(flush: true)
            person.save(flush: true)
//            log.info (" user saved")
            //def auth = new AuthToken(person.username, params.passwd)
            //def authtoken = daoAuthenticationProvider.authenticate(auth)
            //SCH.context.authentication = authtoken
            //redirect uri: '/'
           flash.message = "Your new registration request has been successfully processed. Please log in to your email account ${person.email} to activate your account. Thank you."
//           redirect uri: '/'
           render view: 'success'
           return
        }
        else {
            person.passwd = ''
            render view: 'index', model: [person:person, family: family]
            return
        }
    }
}
